#include <iostream>
using namespace std;


class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

//void f1(A aa)
//{}


//void f1(const A& aa)//临时对象具有常性,因此需要const
//{}

A f2()
{
	A aa;

	// 内联
	cout << "11111" << endl;
	cout << "11111" << endl; 
	cout << "11111" << endl;
	cout << "11111" << endl;
	cout << "11111" << endl;

	return aa;
}
 
void f3()
{
	static A aa3;
}

int main()
{
	//// 传值传参
	//A aa1; //构造
	//f1(aa1); //拷贝构造
	//cout << endl;
	
	
	//// 隐式类型，连续构造+拷贝构造->优化为直接构造
	//f1(1);
	//
	//// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	//f1(A(2));
	//cout << endl;

	
	//// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 （省略了中间对象）
	//A aa2 = f2();
	////const A& aa2 = f2();
	//cout << endl;
	//
	////一个表达式中，连续拷贝构造+赋值重载->无法优化，建议不要这么写
	//A aa3;
	//aa3 = f2(); 
	//cout << endl; 

	//先定义再析构
	A aa1;
	A aa2;
	
	f3();
	cout << "111111" << endl;

	f3();
	cout << "111111" << endl;


	return 0;
}
